java 同步锁（synchronized）的正确使用姿势

最新推荐文章于 2024-04-17 03:55:13 发布
最新推荐文章于 2024-04-17 03:55:13 发布
阅读量7.4k 收藏 10
点赞数 2
分类专栏： 知识点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AndroFarmer/article/details/69219066
版权
关于线程安全，线程锁我们经常会用到，但你的使用姿势正确不，反正我用错了好长一段时间而不自知。所以有了这篇博客总结下线程锁的正确打开姿势
废话不说看例子
一，对整个方法进行加锁
1，对整个方法进行加锁，不同线程访问同一个类的同一个对象 
public class TestRunnable implements Runnable {

	@Override
	public synchronized  void run() {
		// TODO Auto-generated method stub
			for(int i=0;i<10;i++)
			{
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"---"+i);
			}
		}
	

}
public static void main(String[] args)
	{
		TestRunnable runnable=new TestRunnable();
		Thread threadA=new Thread(runnable,"threadA");
		threadA.start();
		
		Thread threadB=new Thread(runnable,"threadB");
		threadB.start();
	}
运行结果：
threadA---0
threadA---1
threadA---2
threadA---3
threadA---4
threadA---5
threadA---6
threadA---7
threadA---8
threadA---9
threadB---0
threadB---1
threadB---2
threadB---3
threadB---4
threadB---5
threadB---6
threadB---7
threadB---8
threadB---9


2，对整个方法进行加锁，不同线程访问同一个类的不同对象 
public class TestRunnable implements Runnable {

	@Override
	public synchronized  void run() {
		// TODO Auto-generated method stub
			for(int i=0;i<10;i++)
			{
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"---"+i);
			}
		}
	

}
	public static void main(String[] args)
	{
		TestRunnable runnableA=new TestRunnable();
		Thread threadA=new Thread(runnableA,"threadA");
		threadA.start();
		
		TestRunnable runnableB=new TestRunnable();
		Thread threadB=new Thread(runnableB,"threadB");
		threadB.start();
	}
运行结果：
threadB---0
threadA---0
threadA---1
threadB---1
threadA---2
threadB---2
threadA---3
threadB---3
threadB---4
threadA---4
threadA---5
threadB---5
threadA---6
threadB---6
threadA---7
threadB---7
threadA---8
threadB---8
threadA---9
threadB---9

小结：对方法整体加锁的做法适用条件是 多个线程访问的必须是同一个类的同一个实例对象


一，对代码块进行加锁
1，对代码块进行加锁，加锁对象为当前类对象，不同线程访问同一个类的同一个对象 
public class TestRunnable implements Runnable {


	@Override
	public void run() {
		// TODO Auto-generated method stub
		synchronized (TestRunnable.this) {
			for (int i = 0; i < 10; i++) {
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "---" + i);
			}
		}
	}


}
public static void main(String[] args)
	{
		TestRunnable runnable=new TestRunnable();
		Thread threadA=new Thread(runnable,"threadA");
		threadA.start();
		
		Thread threadB=new Thread(runnable,"threadB");
		threadB.start();
	}
运行结果：
threadA---0
threadA---1
threadA---2
threadA---3
threadA---4
threadA---5
threadA---6
threadA---7
threadA---8
threadA---9
threadB---0
threadB---1
threadB---2
threadB---3
threadB---4
threadB---5
threadB---6
threadB---7
threadB---8
threadB---9


2，对代码块进行加锁，加锁对象为当前类对象，不同线程访问同一个类的不同对象 
public class TestRunnable implements Runnable {


	@Override
	public void run() {
		// TODO Auto-generated method stub
		synchronized (TestRunnable.this) {
			for (int i = 0; i < 10; i++) {
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "---" + i);
			}
		}
	}


}




	public static void main(String[] args)
	{
		TestRunnable runnableA=new TestRunnable();
		Thread threadA=new Thread(runnableA,"threadA");
		threadA.start();
		
		TestRunnable runnableB=new TestRunnable();
		Thread threadB=new Thread(runnableB,"threadB");
		threadB.start();
	}






 
  
 
  

    运行结果： 
  
 
  
 threadB---0 
  
 threadA---0 
  
 threadB---1 
  
 threadA---1 
  
 threadB---2 
  
 threadA---2 
  
 threadA---3 
  
 threadB---3 
  
 threadA---4 
  
 threadB---4 
  
 threadB---5 
  
 threadA---5 
  
 threadA---6 
  
 threadB---6 
  
 threadB---7 
  
 threadA---7 
  
 threadA---8 
  
 threadB---8 
  
 threadA---9 
  
 threadB---9 
 
 

 

 
 
 

 

 
 
 

 

 
 

   3，对代码块进行加锁，加锁对象为当前类（不是类对象哦），不同线程访问同一个类的同一个对象 
 
 
 
 
  
public class TestRunnable implements Runnable {


	@Override
	public void run() {
		// TODO Auto-generated method stub
		synchronized (TestRunnable.class) {
			for (int i = 0; i < 10; i++) {
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "---" + i);
			}
		}
	}


}
 
  
public static void main(String[] args)
	{
		TestRunnable runnable=new TestRunnable();
		Thread threadA=new Thread(runnable,"threadA");
		threadA.start();
		
		Thread threadB=new Thread(runnable,"threadB");
		threadB.start();
	}
 
 
 
 

   运行结果： 
 
 
 
 threadA---0 
 
 threadA---1 
 
 threadA---2 
 
 threadA---3 
 
 threadA---4 
 
 threadA---5 
 
 threadA---6 
 
 threadA---7 
 
 threadA---8 
 
 threadA---9 
 
 threadB---0 
 
 threadB---1 
 
 threadB---2 
 
 threadB---3 
 
 threadB---4 
 
 threadB---5 
 
 threadB---6 
 
 threadB---7 
 
 threadB---8 
 
 threadB---9 
 
 
  
 
 
 
 
 
  
 
 
 
 
 
  

    4，对代码块进行加锁，加锁对象为当前类（不是类对象哦），不同线程访问同一个类的不同对象 
  
 
  
 
   
public class TestRunnable implements Runnable {


	@Override
	public void run() {
		// TODO Auto-generated method stub
		synchronized (TestRunnable.class) {
			for (int i = 0; i < 10; i++) {
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "---" + i);
			}
		}
	}


}
 
   
	public static void main(String[] args)
	{
		TestRunnable runnableA=new TestRunnable();
		Thread threadA=new Thread(runnableA,"threadA");
		threadA.start();
		
		TestRunnable runnableB=new TestRunnable();
		Thread threadB=new Thread(runnableB,"threadB");
		threadB.start();
	}
 
  
 
  

    运行结果： 
  
 
  
 threadA---0 
  
 threadA---1 
  
 threadA---2 
  
 threadA---3 
  
 threadA---4 
  
 threadA---5 
  
 threadA---6 
  
 threadA---7 
  
 threadA---8 
  
 threadA---9 
  
 threadB---0 
  
 threadB---1 
  
 threadB---2 
  
 threadB---3 
  
 threadB---4 
  
 threadB---5 
  
 threadB---6 
  
 threadB---7 
  
 threadB---8 
  
 threadB---9 
 
 
 
 
  
 
 
 
 
 
  
 
 
 
 
 
  
 
   

     5，对代码块进行加锁，加锁对象为已赋值的变量，不同线程访问同一个类的同一个对象 
   
 
   
 
    
public class TestRunnable implements Runnable {


	@Override
	public void run() {
		// TODO Auto-generated method stub
		synchronized ("test") {
			for (int i = 0; i < 10; i++) {
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "---" + i);
			}
		}
	}


}
 
    
public static void main(String[] args)
	{
		TestRunnable runnable=new TestRunnable();
		Thread threadA=new Thread(runnable,"threadA");
		threadA.start();
		
		Thread threadB=new Thread(runnable,"threadB");
		threadB.start();
	}
 
   
 
   

     运行结果： 
   
 
   
 threadA---0 
   
 threadA---1 
   
 threadA---2 
   
 threadA---3 
   
 threadA---4 
   
 threadA---5 
   
 threadA---6 
   
 threadA---7 
   
 threadA---8 
   
 threadA---9 
   
 threadB---0 
   
 threadB---1 
   
 threadB---2 
   
 threadB---3 
   
 threadB---4 
   
 threadB---5 
   
 threadB---6 
   
 threadB---7 
   
 threadB---8 
   
 threadB---9 
   
 
    
 
   
 
   
 
    
 
   
 
   
 
    

      6，对代码块进行加锁，加锁对象为已赋值的变量，不同线程访问同一个类的不同对象 
    
 
    
 
     
public class TestRunnable implements Runnable {


	@Override
	public void run() {
		// TODO Auto-generated method stub
		synchronized ("test") {
			for (int i = 0; i < 10; i++) {
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "---" + i);
			}
		}
	}


}
 
     
	public static void main(String[] args)
	{
		TestRunnable runnableA=new TestRunnable();
		Thread threadA=new Thread(runnableA,"threadA");
		threadA.start();
		
		TestRunnable runnableB=new TestRunnable();
		Thread threadB=new Thread(runnableB,"threadB");
		threadB.start();
	}
 
    
 
    

      运行结果： 
    
 
    
 threadA---0 
    
 threadA---1 
    
 threadA---2 
    
 threadA---3 
    
 threadA---4 
    
 threadA---5 
    
 threadA---6 
    
 threadA---7 
    
 threadA---8 
    
 threadA---9 
    
 threadB---0 
    
 threadB---1 
    
 threadB---2 
    
 threadB---3 
    
 threadB---4 
    
 threadB---5 
    
 threadB---6 
    
 threadB---7 
    
 threadB---8 
    
 threadB---9 
   
 
   
 
    
 
   
 
   

     小结：当对代码块进行加锁时，当加锁对象是一个确定值时（当前类，或者已赋值的变量） 不同线程访问同一个类的不同对象时也可以实现线程同步 
   
 
   
 
    
 
   
 
   

     最后奉上线程锁在实际开发中的应用----单例模式 
   
 
   
 
    
 
   
 
   

     1，懒汉式写法 
   
 
   
 
    
public class Singleton {
    private static Singleton instance;
    private Singleton (){}
    public static synchronized Singleton getInstance() {
	if (instance == null) {
	    instance = new Singleton();
	}
	return instance;
    }
}
2，懒汉式写法升级版（双重校验锁） 性能优于第一种 
   
 
   
 
    
public class Singleton {  
    private static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
} 
 
    
 
     
 
    
 3，饿汉式写法，不依赖于线程同步锁，依赖于静态变量和类的同步加载实现线程安全 
    
public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton (){}
    public static Singleton getInstance() {
	return instance;
    }
}
 
    
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
  
 
  
 
   
 
  
 
  
 
 
 
 
 

 

 
 
 

 

 
 
 


                

        

        

    




    

      

        

            

              
                
                  AndroFarmer
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    2
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    10
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  4
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
Java中synchronized正确使用方法解析

				
			

			

				

					08-25
				

			

		

		

			
				
主要介绍了Java中syncronized正确使用方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

			
		

	



                

              
                



	

		

			

				
					
Java 同步锁(synchronized)详解及实例

				
			

			

				

					08-30
				

			

		

		

			
				
主要介绍了Java 同步锁(synchronized)详解及实例的相关资料,需要的朋友可以参考下

			
		

	



                


  
              

                


	

		

			

				
					
Java 中 synchronized的用法详解(四种用法)

				
			

			

				

					09-03
				

			

		

		

			
				
Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。本文给大家介绍java中 synchronized的用法，对本文感兴趣的朋友一起看看吧

			
		

	





	

		

			

				
					
Java多线程（二）——synchronized 详解

				
			

			

				

					m0_45198397的博客
				

				

					01-05
					
					4859
					
				

			

		

		

			
				
java多线程

			
		

	



		

			
		



	

		

			

				
					
Synchronized锁详解(全网最细)

					
最新发布

				
			

			

				

					Anakki的博客
				

				

					04-17
					
					1254
					
				

			

		

		

			
				
正常来说a获取到锁后b不能获取锁，但是当一个实例内的a方法和b方法都是用一把锁上锁时，同一个线程访问a和b就需要重入的能力，比如在a方法中访问b方法，那么a的锁x已经被抢占了，如果不支持重入，那么访问b的时候会发现x锁已经被自己抢占而无法访问，支持重入的原理也就是在这里判断一下当前方法的锁是否是本线程拥有的锁。所以锁消除可以节省毫无意义的请求锁的时间。JVM在JDK1.6后会有几种状态，线程获取对象时，分别会判断对象锁的状态，以此来决定线程是否进入阻塞，或者获取到锁对象执行代码块，或者自旋等接下来的动作。

			
		

	





	

		

			

				
					
Java关键字之synchronized详解【Java多线程必备】

				
			

			

				

					Mr.绵羊的知识星球
				

				

					04-05
					
					5429
					
				

			

		

		

			
				
1. synchronized详解 2. synchronized使用注意事项和案例

			
		

	





	

		

			

				
					
聊聊Java关键字synchronized

				
			

			

				

					Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
				

				

					02-13
					
					3557
					
				

			

		

		

			
				
具体例子，某段线程得到锁Test.class之后，执行临界代码逻辑，可能会先执行变量b初始化的逻辑，在执行a变量初始化的逻辑，但是最终结果都会执行a+b的逻辑。每个线程使用synchronized获得锁操作临界资源时，首先需要获取临界资源的值，为了保证临界资源的值是最新的，JMM模型规定线程必须将本地工作内存清空，到共享内存中加载最新的进行操作。正是由于锁互斥的失败，导致两个线程同时到临界区域加载资源，获得的count都是0，经过自增后都是1，导致数据少了1。

			
		

	





	

		

			

				
					
Java synchronized详解

				
			

			

				

					杨宇昌的博客
				

				

					03-17
					
					8669
					
				

			

		

		

			
				
java并发 synchronized详解

			
		

	





	

		

			

				
					
【Java】synchronized同步锁详解

				
			

			

				

					12-22
				

			

		

		

			
				
 synchronized同步锁（悲观锁）2.1 synchronized 作用范围2.2 synchronized 核心组件2.3 synchronized 实现 1. Java锁的种类 1.1 乐观锁 乐观锁是一种乐观思想，即认为读多写少，遇到并发写的可能性低。 每次去拿...

			
		

	





	

		

			

				
					
Java使用synchronized实现互斥锁功能示例

				
			

			

				

					08-19
				

			

		

		

			
				
主要介绍了Java使用synchronized实现互斥锁功能,结合实例形式分析了Java使用synchronized互斥锁功能简单实现方法与操作技巧,需要的朋友可以参考下

			
		

	





	

		

			

				
					
详细解读java同步之synchronized解析

				
			

			

				

					08-26
				

			

		

		

			
				
synchronized关键字是Java里面最基本的同步手段，下面我们来一起学习一下

			
		

	





	

		

			

				
					
java线程-synchronized详解

				
			

			

				

					BASK2311的博客
				

				

					02-03
					
					2071
					
				

			

		

		

			
				
synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized 翻译为中文的意思是同步，也称之为”同步锁“。synchronized的作用是保证在同一时刻， 被修饰的代码块或方法只会有一个线程执行，以达到保证并发安全的效果。

			
		

	





	

		

			

				
					
Java.synchronized

				
			

			

				

					m0_58407085的博客
				

				

					04-19
					
					974
					
				

			

		

		

			
				
偏向锁就是一个标志，在对象头存储当前锁偏向的线程，当一个线程访问时，会先判断这个标志是否等于当前线程，如果等于当前线程，那就直接获得锁，如果为空，就把当前锁的对象头，设置成自己，如果不等于自己，锁就会升级）。（1）synchronized的特性     原子性，内存可见性，有序性（指令重排序），非公平锁，可重入锁，不可中断（这里的不可中断不是指线程不能中断，而是指当拿不到锁的时候，这个阻塞的过程不可以中断）。5.synchronized的锁机制/synchronized的锁升级，锁膨胀，锁消除，锁粗化。

			
		

	





	

		

			

				
					
JAVA系列---synchronized的用法

				
			

			

				

					lipviolet的博客
				

				

					04-28
					
					4622
					
				

			

		

		

			
				
1. 背景
1.1 多线程操作同一个对象
1.1.1  不加锁
public class HandleThread {
    public static void main(String[] args) {
        SyncThread s1 = new SyncThread();
        SyncThread s2 = new SyncThread();
        Thread t1 = new Thread(s1);
//        Thread t2 = new Threa

			
		

	





	

		

			

				
					
Java中Synchronized的四种用法

				
			

			

				

					Isonion的博客
				

				

					08-24
					
					3715
					
				

			

		

		

			
				
java中Synchronized的四种用法，修饰代码块、修饰方法、修饰静态方法、修饰类

			
		

	





	

		

			

				
					
Java中synchronized的用法

				
			

			

				

					weixin_62570753的博客
				

				

					04-15
					
					2192
					
				

			

		

		

			
				
当一个线程进入同步代码块时，它就获得了该对象的锁，其他线程将被阻塞，直到执行线程释放锁并退出该代码块。需要注意的是，同步代码块的粒度比同步方法更细，可以有效减小同步开销。非静态同步方法的锁是该方法所属对象的实例，而静态同步方法的锁是该方法所属类的Class对象。这意味着，当一个线程进入静态同步方法时，其他线程将不能同时访问该类的静态同步方法，但可以同时访问该类的非静态同步方法和其他非同步方法。当一个线程进入同步方法时，它就获得了该方法所对应的对象的锁，其他线程将被阻塞，直到执行线程释放锁并退出该方法。

			
		

	





	

		

			

				
					
java中的synchronized

				
			

			

				

					qq_56936805的博客
				

				

					11-30
					
					1045
					
				

			

		

		

			
				
synchronized是Java中的关键字，用于实现线程之间的同步。它提供了一种独占锁的机制，确保在同一个时刻，只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作)，同时我们还应该注意到synchronized另外一个重要的作用，synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到（保证可见性，完全可以替代Volatile功能），这点确实也是很重要的。

			
		

	





	

		

			

				
					
Java关键字——synchronized

				
			

			

				

					qq_35854212的博客
				

				

					02-16
					
					681
					
				

			

		

		

			
				
synchronized使用和原理全解

			
		

	





	

		

			

				
					
Java中Synchronized的用法

					
热门推荐

				
			

			

				

					阳光日志
				

				

					06-24
					
					49万+
					
				

			

		

		

			
				
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 
1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 
3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4..

			
		

	





	

		

			

				
					
java同步锁synchronized使用案例

				
			

			

				

					08-30
				

			

		

		

			
				
Java中的synchronized关键字是一种用于实现同步的机制。它可以应用于方法和代码块，以确保在同一时刻只有一个线程可以访问共享资源。

以下是一些使用synchronized关键字的案例：

1. 多线程访问共享资源：考虑一个银行账户的例子，多个线程同时尝试改变账户余额。为了避免竞态条件和数据不一致的问题，可以使用synchronized关键字来同步访问共享资源，例如在deposit()和withdraw()方法上使用synchronized。

2. 线程安全的容器：在多线程环境下，使用synchronized可以确保线程安全的访问容器。例如，可以在对ArrayList的增删操作上使用synchronized，以避免多个线程同时修改容器而导致的错误。

3. 生产者-消费者模型：生产者线程负责生成数据，消费者线程负责消费数据。为了保证顺序，可以使用synchronized来同步这两个线程。例如，在生产者方法的代码块和消费者方法的代码块上使用synchronized。

4. 对象锁和类锁：synchronized可以用来实现对象级别的锁和类级别的锁。对象级别的锁是在每个对象实例上加锁，而类级别的锁是在类级别上加锁。例如，在静态方法上使用synchronized即可获得类级别的锁。

总结来说，synchronized关键字在Java中的使用案例非常广泛，可以用于多线程环境下保证共享资源的安全访问，避免并发操作导致的数据不一致问题。通过使用synchronized，可以有效地控制多个线程对共享资源的访问，确保线程安全性。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 4

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值